1455C - Ping-pong - CodeForces Solution

#include <iostream>
#include <bits/stdc++.h>
#define lp(x,i,n,s) for(ll x = i; x < n; x+=s)
#define lpi(x,i,n,s) for(ll x = i; x >= n; x-=s)
#define vll vector<ll>
#define vd vector<double>
#define vc vector<char>
#define vs vector<string>
#define pll pair<ll,ll>
#define pls pair<ll,string>
#define pd pair<double,double>
#define pbo(x) push_back(x)
#define pb push_back
typedef long long int ll;
typedef unsigned long long ull;
typedef long double lld;
using namespace std;

// GCC Optimizations
#pragma GCC diagnostic ignored "-Wunused-variable" // Ignore unused variable warning
#pragma GCC diagnostic ignored "-Wunknown-pragmas" // Ignore unknown pragmas warning
#pragma GCC optimize("Ofast")
#pragma GCC target("fma,sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")
#pragma GCC optimize("unroll-loops")

// Macros
#define ld long double

// Constants
constexpr long long SZ = 1e5 + 7;
constexpr long long inf = 1e18;
constexpr long long mod = 1e9 + 7;
constexpr long long MOD = 998244353;
constexpr long double PI = 3.141592653589793238462;

// Macros
#define vt vector
#define all(X) (X).begin(), (X).end()
#define allr(X) (X).rbegin(), (X).rend()
#define sz(X) (int)X.size()

#define each(x, a) for (auto &x: a)
#define forn(i, n) for (int i = 0; i < n; ++i)
#define forr(i, n) for (int i = n; i >=0; --i)

#define ff first
#define inf 1000000000000000005
#define ss second
#define nl '\n'

#define setbits(X) __builtin_popcountll(X)
#define fix(X) fixed << setprecision(X)
#define mem0(X) memset((X), 0, sizeof((X)))
#define mem1(X) memset((X), -1, sizeof((X)))

// Debug Functions
#ifndef ONLINE_JUDGE
#define debug(x) cerr << #x <<" "; _print(x); cerr << endl;
#else
#define debug(x)
#endif

void _print(ll t) {cerr << t;}
void _print(int t) {cerr << t;}
void _print(string t) {cerr << t;}
void _print(char t) {cerr << t;}
void _print(lld t) {cerr << t;}
void _print(double t) {cerr << t;}
void _print(ull t) {cerr << t;}

// Min Max
template<class T>
bool amin(T &a, const T &b) { return b < a ? a = b, 1 : 0; }
template<class T>
bool amax(T &a, const T &b) { return a < b ? a = b, 1 : 0; }

// Operator overloads <<, >>
template <class T, class V> void _print(pair <T, V> p);
template <class T> void _print(vector <T> v);
template <class T> void _print(set <T> v);
template <class T, class V> void _print(map <T, V> v);
template <class T> void _print(multiset <T> v);
template <class T, class V> void _print(pair <T, V> p) {cerr << "{"; _print(p.ff); cerr << ","; _print(p.ss); cerr << "}";}
template <class T> void _print(vector <T> v) {cerr << "[ "; for (T i : v) {_print(i); cerr << " ";} cerr << "]";}
template <class T> void _print(set <T> v) {cerr << "[ "; for (T i : v) {_print(i); cerr << " ";} cerr << "]";}
template <class T> void _print(multiset <T> v) {cerr << "[ "; for (T i : v) {_print(i); cerr << " ";} cerr << "]";}
template <class T, class V> void _print(map <T, V> v) {cerr << "[ "; for (auto i : v) {_print(i); cerr << " ";} cerr << "]";}

// Google
int tc_cnt = 1;
#define ns()               cout << "Case #" << tc_cnt ++ << ": ";

// Power under mod (a ^ b) % mod
ll modpow(ll a, ll b, ll m = mod) {
    a = a & m; ll ans = 1;
    while (b) {
        if (b & 1) { ans = (ans * a) % m; }
        b = b >> 1; a = (a * a) % m;
    }
    return ans;
}

ll ceil_div(ll a, ll b) {return a % b == 0 ? a / b : a / b + 1;}
// Inverse Mod (1 / a) % mod
int modinv(int a, int m = mod) { return modpow(a, m - 2); }

// Modular Arithmetic
int modadd(int a, int b, int m = mod) { a = a % m; b = b % m; return (((a + b) % m) + m) % m; }
int modsub(int a, int b, int m = mod) { a = a % m; b = b % m; return (((a - b) % m) + m) % m; }
int modmul(int a, int b, int m = mod) { a = a % m; b = b % m; return (((a * b) % m) + m) % m; }
int moddiv(int a, int b, int m = mod) { a = a % m; b = b % m; return (modmul(a, modinv(b, m), m) + m) % m; }

// GCD
int gcd(int a, int b) { if (b == 0) { return a; } return gcd(b, a % b); }

// LCM
int lcm(int a, int b) { return (a / gcd(a, b)) * b; }

// Directions
const int dx[8] = {0, 1, -1, 0, -1, -1, 1, 1};
const int dy[8] = {1, 0, 0, -1, 1, -1, -1, 1};
// ordered_set
// Header files, namespaces,
// macros as defined above
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;

template <typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
 //<!-------------------------------------template ends------------------------------------------------------------------->

//write your code here........

ll i,t,n,k,m;

// ll find(vector<ll>&v,ll x,ll ind,ll n)
// {
//     if(ind==n)
//     {
//         if(!is_sorted(all(v)))return 1e15;
//         else return 0;
//     }
//     if(v[ind]>x)
//     {
//         swap(v[ind],x);
//         ll g=find(v,x,ind+1,n)+1ll;
//         swap(v[ind],x);
//         ll h=find(v,x,ind+1,n);
//         return min(g,h);
//     }
//     else
//         return find(v,x,ind+1,n);
// }

void solve(){
    // cin >> t;
    // while(t--){
    //     ll n,x;
    //     cin>>n>>x;
    //     vector<ll>a(n);
    //     lp(i,0,n,1)
    //     {
    //         cin>>a[i];
    //     }
    //     ll cnt = 0;
    //     bool flag = true;
    //     while(!is_sorted(all(a)) && flag){
    //         debug(a);
    //         for(ll i = 0; i < n; i++){
    //             if(a[i] > x){
    //                 cnt++;
    //                 swap(a[i],x);
    //                 flag = false;
    //                 break;
    //             }
    //         }
    //         debug(x);
    //         debug(a);
    //         if(is_sorted(all(a))) break;
    //         for(ll i = 0; i < n; i++){
    //             if(a[i] > x){
    //                 cnt++;
    //                 flag = false;
    //                 swap(a[i],x);
    //                 break;
    //             }
    //         }
    //         debug(a);
    //         flag = flag^1;
    //     }
    //     if(is_sorted(all(a))){
    //         cout << cnt << endl;
    //     }
    //     else{
    //         cout << -1 << endl;
    //     }
    //     cin >> n;
    //     vll v(n);
    //     ll cnt = 0;
    //     for(ll i = 0; i < n; i++){
    //         cin >> v[i];
    //         ll val = sqrt(v[i]);
    //         double c = sqrt(v[i]);
    //         if(c != val){
    //             cnt++;
    //         }
    //     }
    //     if(cnt > 0){
    //         cout << "YES" << endl;
    //     }
    //     else{
    //         cout << "NO" << endl;
    //     }
    // }
    // cin >> t;
    // while(t--){
    //     cin >>n >> k;
    //     ll ans = 1;
    //     for(int i=0;i<k;i++) ans=(ans*n)%mod;
    //     cout << ans << endl;
    // }
    // t = 1;
    // while(t--){
    //     cin >> n;
    //     vll v;
    //     ll product = 1;
    //     for(ll i = 1; i < n; i++){
    //         if(__gcd(n,i) == 1){
    //             v.push_back(i);
    //             product = (product*i)%n;
    //         }
    //     }
    //     debug(v);
    //     if(product != 1){
    //         v.pop_back();
    //     }
    //     cout << v.size() << endl;
    //     for(ll val : v){
    //         cout << val <<  " ";
    //     }
    //     cout << endl;
    // }
    // cin >> t;
    // while(t--){
    //     cin >> n >> k;
    //     string s = "abc";
    //     for(ll i = 0; i < n ; i++){
    //         cout << s[i%3];
    //     }
    //     cout << endl;
    // }
    // cin >> t;
    // while(t--){
    //     cin >> n >> m;
    //     vector<string> v(n);
    //     for(ll i = 0; i < n; i++){
    //         cin >> v[i];
    //     }
    //     ll ans = 0;
    //     vector<vector<ll>> dp(n,vector<ll>(m));
    //     for(ll i = 0; i < n; i++){
    //         vector<ll> suffix(m);
    //         for(ll j = m-1; j >= 0; j--){
    //             if(v[i][j] == '*' && j == m-1){
    //                 suffix[j] = 1;
    //             }
    //             else if(v[i][j]== '*'){
    //                 suffix[j] = 1 + suffix[j + 1];
    //             }
    //         }
    //         // debug(suffix);
    //         ll cnt = 0;
    //         for(ll j = 0; j < m; j++){
    //             if(i == 0){
    //                 if(v[i][j] == '*'){
    //                     dp[i][j] = 1;
    //                 }
    //             }
    //             else{
    //                 if(j == 0 || j == m - 1){
    //                     if(v[i][j] == '*'){
    //                         dp[i][j] = 1;
    //                     }
    //                 }
    //                 else{
    //                     if(v[i][j] == '*'){
    //                         ll _min = min(cnt,suffix[j + 1]);
    //                         for(ll d = 0; d <= _min; d++){
    //                             if(dp[i-1][j] >= d){
    //                                 dp[i][j]++;
    //                             }
    //                         }
    //                     }
    //                 }
    //             }
    //             if(v[i][j] == '*') cnt++;
    //             else cnt = 0;
    //         }
    //     }
    //     // debug(dp);
    //     for(ll i = 0; i < n; i++){
    //         for(ll j = 0; j < m; j++){
    //             ans += dp[i][j];
    //         }
    //     }
    //     cout << ans << endl;
    // }
    // cin >> t;
    // while(t--){
    //     cin >> n >> m;
    //     vll a(n);
    //     for(ll i =0; i < n; i++){
    //         cin >> a[i];
    //     }
    //     ll cnt = 0;
    //     for(ll i = n-1; i >= 0; i--){
    //         if(a[i] == i + 1) cnt++;
    //         else break;
    //     }
    //     ll r; double p;
    //     ll asli_prob = n - cnt;
    //     vt<double> to_be_followed;
    //     while(m--){
    //         cin >> r >> p;
    //         if(r >= asli_prob){
    //             to_be_followed.push_back(p);
    //         }
    //     }
    //     cout << setprecision(8);
    //     if(asli_prob == 0){
    //         cout << (1.0) << endl;
    //         continue;
    //     }
    //     m = to_be_followed.size();
    //     vector<vector<double>> dp(m + 1,vector<double>(2));
    //     dp[0][0] = 1.0;
    //     for(ll i = 1; i <= m; i++){
    //         dp[i][0] = dp[i-1][0]*(1 - to_be_followed[i-1]);
    //         dp[i][1] = dp[i-1][0]*(to_be_followed[i-1])
    //                     + dp[i-1][1]*(to_be_followed[i-1])
    //                     + dp[i-1][1]*(1 - to_be_followed[i-1]);
    //     }
    //     cout << dp[m][1] << endl;
    // }
    // cin >> t;
    // while(t--){
    //     string s;
    //     cin >> s;
    //     cout << s.length() << endl;
    // }
    // cin >> t;
    // while(t--){
    //     cin >> n;
    //     ll pos = 0;
    //     ll jump = 1;
    //     while(pos < n){
    //         pos += jump; jump++;
    //     }
    //     jump--;
    //     if(pos - n == 1){
    //         cout << (jump + 1) << endl;
    //     }
    //     else{
    //         cout << (jump) << endl;
    //     }
    // }
    cin >> t;
    while(t--){
        ll x,y;
        cin >> x >> y;
        cout << (x - 1) << " " << y << endl;
    }
}


//<!---------------------------------------------------------------------------------------------------------------------->


int32_t main(){
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    #ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
    #endif

    #ifndef ONLINE_JUDGE
    freopen("error.txt", "w", stderr);
    #endif

    solve();

    return 0;
}